//! Yaya安全服务层基础演示
//! 
//! 演示安全服务层的基本功能和使用方式

use yaya_safe_services::prelude::*;
use log::{info, error};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    env_logger::init();
    
    info!("Yaya安全服务层基础演示启动");
    
    // 创建服务管理器
    let mut service_manager = ServiceManager::new()?;
    info!("服务管理器创建成功");
    
    // 启动所有服务
    service_manager.start_all_services()?;
    info!("所有服务已启动");
    
    // 演示各个服务的基本功能
    demo_memory_service(&service_manager)?;
    demo_process_service(&service_manager)?;
    demo_filesystem_service(&service_manager)?;
    demo_network_service(&service_manager)?;
    
    // 停止所有服务
    service_manager.stop_all_services()?;
    info!("所有服务已停止");
    
    info!("基础演示完成");
    Ok(())
}

fn demo_memory_service(service_manager: &ServiceManager) -> Result<(), Box<dyn std::error::Error>> {
    info!("--- 内存服务演示 ---");
    
    let mem_service = service_manager.get_memory_service();
    let mut mem_guard = mem_service.lock().map_err(|e| format!("无法锁定内存服务: {}", e))?;
    
    // 分配内存
    let ptr = mem_guard.allocate(1024)?;
    info!("分配内存: 地址={}, 大小=1024 字节", ptr);
    
    // 写入数据
    let test_data = b"Hello, Yaya Safe Services!";
    mem_guard.write_memory(ptr, test_data)?;
    info!("写入内存数据: 大小={} 字节", test_data.len());
    
    // 读取数据
    let read_data = mem_guard.read_memory(ptr, test_data.len())?;
    info!("读取内存数据: 大小={} 字节", read_data.len());
    assert_eq!(test_data, read_data.as_slice());
    
    // 获取内存状态
    let (used, free) = mem_guard.get_status();
    info!("内存状态: 已使用={} 字节, 空闲={} 字节", used, free);
    
    // 释放内存
    mem_guard.free(ptr)?;
    info!("释放内存: 地址={}", ptr);
    
    info!("内存服务演示完成");
    Ok(())
}

fn demo_process_service(service_manager: &ServiceManager) -> Result<(), Box<dyn std::error::Error>> {
    info!("--- 进程服务演示 ---");
    
    let proc_service = service_manager.get_process_service();
    let mut proc_guard = proc_service.lock().map_err(|e| format!("无法锁定进程服务: {}", e))?;
    
    // 创建进程
    let pid = proc_guard.create_process("demo_process", "echo 'Hello World'", 4096)?;
    info!("创建进程: PID={}, 名称=demo_process", pid);
    
    // 获取进程信息
    let process_info = proc_guard.get_process_info(pid)?;
    info!("进程信息: PID={}, 名称={}, 状态={:?}, 内存使用={} 字节", 
          process_info.pid, process_info.name, process_info.state, process_info.memory_usage);
    
    // 列出所有进程
    let processes = proc_guard.list_processes();
    info!("当前进程数量: {}", processes.len());
    for process in processes {
        info!("  - PID={}, 名称={}, 状态={:?}", 
              process.pid, process.name, process.state);
    }
    
    // 终止进程
    proc_guard.terminate_process(pid)?;
    info!("终止进程: PID={}", pid);
    
    info!("进程服务演示完成");
    Ok(())
}

fn demo_filesystem_service(service_manager: &ServiceManager) -> Result<(), Box<dyn std::error::Error>> {
    info!("--- 文件系统服务演示 ---");
    
    let fs_service = service_manager.get_filesystem_service();
    let mut fs_guard = fs_service.lock().map_err(|e| format!("无法锁定文件系统服务: {}", e))?;
    
    // 创建目录
    fs_guard.create_directory("/demo")?;
    info!("创建目录: /demo");
    
    // 创建文件
    fs_guard.create_file("/demo/test.txt")?;
    info!("创建文件: /demo/test.txt");
    
    // 写入文件
    let file_content = b"This is a test file content.";
    fs_guard.write_file("/demo/test.txt", file_content)?;
    info!("写入文件: /demo/test.txt, 大小={} 字节", file_content.len());
    
    // 读取文件
    let read_content = fs_guard.read_file("/demo/test.txt")?;
    info!("读取文件: /demo/test.txt, 大小={} 字节", read_content.len());
    assert_eq!(file_content, read_content.as_slice());
    
    // 列出目录
    let dir_contents = fs_guard.list_directory("/demo")?;
    info!("目录内容: /demo");
    for (name, node_type, size) in dir_contents {
        info!("  - {} ({:?}, {} 字节)", name, node_type, size);
    }
    
    // 清理
    fs_guard.delete("/demo/test.txt")?;
    info!("删除文件: /demo/test.txt");
    
    fs_guard.delete("/demo")?;
    info!("删除目录: /demo");
    
    info!("文件系统服务演示完成");
    Ok(())
}

fn demo_network_service(service_manager: &ServiceManager) -> Result<(), Box<dyn std::error::Error>> {
    info!("--- 网络服务演示 ---");
    
    let net_service = service_manager.get_network_service();
    let mut net_guard = net_service.lock().map_err(|e| format!("无法锁定网络服务: {}", e))?;
    
    // 创建连接
    let conn_id = net_guard.create_connection(ConnectionType::TCP, "localhost", 8080)?;
    info!("创建网络连接: ID={}, 类型=TCP, 远程地址=localhost:8080", conn_id);
    
    // 发送数据
    let send_data = b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n";
    let sent_size = net_guard.send_data(conn_id, send_data)?;
    info!("发送网络数据: 连接ID={}, 大小={} 字节", conn_id, sent_size);
    
    // 接收数据
    let received_data = net_guard.receive_data(conn_id, 1024)?;
    info!("接收网络数据: 连接ID={}, 大小={} 字节", conn_id, received_data.len());
    
    // 关闭连接
    net_guard.close_connection(conn_id)?;
    info!("关闭网络连接: ID={}", conn_id);
    
    info!("网络服务演示完成");
    Ok(())
}